home *** CD-ROM | disk | FTP | other *** search
/ Gekkan Dennou Club 147 / Gekkan Dennou Club - 2000.8 Vol. 147 (Japan).7z / Gekkan Dennou Club - 2000.8 Vol. 147 (Japan) (Track 1).bin / fdimg / —‹Œêsrc.lzh / fep.c < prev    next >
C/C++ Source or Header  |  1993-03-10  |  31KB  |  1,481 lines
  1. #include    "3DDEF.H"
  2. #include    "GLOBAL.H"
  3. #include    "FORWARD.H"
  4. #include    "XCODE.H"
  5.  
  6. #define    FUSI_MAX    20
  7. #define        BS        ('H'-'@')
  8.  
  9. extern WORD UNDER_FLAG;
  10.  
  11. extern int XF3_RUN;
  12. extern UBYTE koho_10[10+1][MAXLINE];
  13. extern UWORD koho_10x[10+1];
  14. extern UWORD koho_max;
  15.  
  16. extern UBYTE XF_NEXT_BLOCK_KEY;
  17. extern UBYTE XF_BEFORE_BLOCK_KEY;
  18. extern UBYTE XF_RIGHT_KOHO_KEY;
  19. extern UBYTE XF_LEFT_KOHO_KEY;
  20.  
  21. extern int kigou_or_code;
  22. extern UBYTE f7_buff[32];
  23. extern UBYTE ledpat;
  24.  
  25. WORD VERSION;
  26.  
  27. /* FEP のモード保持 */
  28. /* "(Z:全角,H:半角) */
  29. /* (K:カナ,-) */
  30. /* (R:ローマ字入力,-)" */
  31. /* (M:無変換,H:変換)" */
  32. void
  33. fep_mode_set(STR mode)
  34. {
  35.     fep_mode_set0(mode);
  36.     strcpy(FP_MODE,mode);
  37.     disp_hmode();
  38. }
  39.  
  40. void
  41. fep_mode_set0(STR mode)
  42. {
  43.     LEDMOD(6,mode[0] == 'Z');
  44.     LEDMOD(0,mode[1] == 'K');
  45.     LEDMOD(1,mode[2] == 'R');
  46.     LEDMOD(5,mode[4] == 'H');
  47. }
  48.  
  49. void
  50. fep_hmode_set(UBYTE c)
  51. {
  52.     FP_MODE[3] = c;
  53. }
  54.  
  55.  
  56. /* キーバッファのクリア */
  57. void
  58. fep_key_clear()
  59. {
  60.     if (DUM_FLAG) {
  61. /*        return;*/
  62.         while(INPOUT(0xff));
  63.     } else {
  64.         while(KNJCTRL(53));
  65.     }
  66. }
  67.  
  68. UBYTE big_2byte[] = "あいうえおやゆよつアイウエオヤユヨツ";
  69. UBYTE big_1byte[] = "ｱｲｳｴｵﾔﾕﾖﾂ";
  70.  
  71.  
  72.  
  73. /* １文字入力 */
  74. /* 0x0000 ～ 0xffff */
  75. UINT
  76. fep_inkey()/* ??? */
  77. {
  78.     register UINT c,c_small;
  79.     register UWORD macro_command;
  80.     register UBYTE *p;
  81.  
  82.     if (MACRO_EXE_FLAG) {
  83.         if (macro_command = MACRO_SEQUENCE[MACRO_COUNT++]) {
  84.             return(macro_command);
  85.         } else {
  86.             if (--MACRO_EXE_FLAG) {
  87.                 MACRO_COUNT = 0;
  88.                 return(MACRO_SEQUENCE[MACRO_COUNT++]);
  89.             }
  90.         }
  91.     }
  92.  
  93. head:
  94.     c = fep_inkey0();
  95.  
  96. /* UBYTE FP_MODE[16] = "Z-RHH";    FEP のモード保持 <= "(Z,H)(K,-)(R,-)(H,M)" */
  97.     if ((VERSION >= 300) && (fep_shift_ctrl() == 0x10)
  98.                 /* SHIFT なら 0x10, CTRL なら 0x20 */
  99.     &&  ((FP_MODE[1] == 'K') || (FP_MODE[2] == 'R'))) {
  100.         if (c && 0xff00) {    /* ２バイト文字だ */
  101.             if (jstrchr(big_2byte,c)) {    /* 含まれる */
  102.                 c--;
  103.             }
  104.         } else {        /* １バイト文字だ */
  105.             if (p = strchr(big_1byte,c)) {    /* 含まれる */
  106.                 switch(*p) {
  107.                     case 'ｱ':
  108.                     c = 'ｧ';break;
  109.                     case 'ｲ':
  110.                     c = 'ｨ';break;
  111.                     case 'ｳ':
  112.                     c = 'ｩ';break;
  113.                     case 'ｴ':
  114.                     c = 'ｪ';break;
  115.                     case 'ｵ':
  116.                     c = 'ｫ';break;
  117.                     case 'ﾔ':
  118.                     c = 'ｬ';break;
  119.                     case 'ﾕ':
  120.                     c = 'ｭ';break;
  121.                     case 'ﾖ':
  122.                     c = 'ｮ';break;
  123.                     case 'ﾂ':
  124.                     c = 'ｯ';break;
  125.                 }
  126.             }
  127.         }
  128.     }
  129. /*
  130. {
  131.     UBYTE w[MAXLINE];
  132.  
  133.     sprintf(w,"[%x]",c);
  134.     under_print(w);
  135. }
  136. */
  137.     if (MACRO_DEF_FLAG) {        /* マクロ定義中だ */
  138.         if (MACRO_COUNT >= MACRO_MAX_STEP-1) {
  139. /*        if (MACRO_COUNT >= 10) {*/
  140.                 /* ストローク数が多すぎる */
  141.             MACRO_SEQUENCE[0] = 0;
  142.             MACRO_COUNT = MACRO_DEF_FLAG = 0;
  143.             under_print("[マクロ記録のステップが多すぎます：中断]");
  144.             etc_beep();
  145.             goto head;
  146.         } else {
  147.             MACRO_SEQUENCE[MACRO_COUNT++] = c;
  148.         }
  149.     }
  150.     return(c);
  151. }
  152.  
  153. /* １文字入力 */
  154. /* 0x0000 ～ 0xffff */
  155. UINT
  156. fep_inkey0()/* ??? */
  157. {
  158.     register UINT c;
  159.     UINT q_func;
  160.  
  161.     if (c = fep_buffer) {
  162.         fep_buffer = 0;
  163.         return(c);
  164.     }
  165.  
  166.     if (kigou_or_code) {
  167.         if (kigou_or_code == 1) {    /* 記号入力 */
  168.             return(xf_kigou());    /* ,,, */
  169.         } else {            /* コード入力 */
  170.             return(xf_code_input());
  171.         }
  172.     }
  173. /*etc_beep();*/
  174.     while(1) {
  175.         if (c = fep_INKEY()) {        /* 何か入力があった */
  176.                 return(c);
  177.         } else if (q_func = fep_qxf()) {    /* XF もしくはファンクションキーである */
  178.             etc_while_fep_qxf();
  179.             etc_click();
  180.             return(q_func);
  181.         }
  182.     }
  183. }
  184. /*   7        6     5         4          3         2    1     0     */
  185. /* A [XF3]      [XF2] [XF1]  [HELP]   [登録]     [記号] [.]   [,]   */
  186. /* B [ひらがな] [INS] [CAPS] [コード] [ローマ字] [かな] [XF5] [XF4] */
  187.  
  188. /*
  189. [HELP]=6
  190. [登録]=7
  191. [記号]=8
  192. [ひらがな]=9
  193. [INS]=A
  194. [CAPS]=B
  195. [コード]=C
  196. [ローマ字]=D
  197. [かな]=E
  198. */
  199.  
  200. /* ファンクションキーが押されたか？ */
  201. /* マウスもサポート */
  202. UINT
  203. fep_qxf2()
  204. {
  205.     register int k0,k1 = 0,ks,i;
  206.  
  207.     if ((k0 = BITSNS(0x0c) & 0b11111001) || (k1 = (BITSNS(0x0d) & 0b00011111))) {
  208.         if (k0 & 1) {    /* [全角] */
  209.             return(0x10f);    /* シフトの類は無視する */
  210.         }
  211.         k0 = (k0 >> 3) | (k1 << 5);
  212.         for(i = k1 = 1;i <= 10;i++,k1 <<= 1) {
  213.             if (k0 & k1) {    /* 絶対途中でＢＲＥＡＫする */
  214.                 break;
  215.             }
  216.         }
  217.         if (ks = (BITSNS(0x0e) & 0b00000011)) {    /* SHIFT, CTRL */
  218.             if (ks & 1) {
  219.                 return(i + 0x210);        /* SHIFT */
  220.             } else {
  221.                 return(i + 0x220);        /* CTRL */
  222.             }
  223.         }
  224.         return(i+0x200);
  225.     } else {
  226.         if (MS_GETDT() & 0b00000000000000001111111100000000) {
  227.             return(0x210);    /* 左ボタンが押された */
  228.         }
  229.         return(0);
  230.     }
  231. }
  232.  
  233. /* ＸＦキーが押されたか？ */
  234. UINT
  235. fep_qxf()
  236. {
  237.     register int k;
  238.  
  239.     if ((!DUM_FLAG) && (B_BPEEK(fep_p2) != fep_p2_last)) {
  240.         return(0);
  241.     }
  242.  
  243.     if (k = BITSNS(6)) {
  244.         if (k & 0b10000000) {
  245.             k = 0;/*FEP_DEL_CODE;*/
  246.         } else if (k & 0b01000000) {
  247.             k = FEP_HOME_CODE;
  248.         } else {
  249.             k = 0;
  250.         }
  251.     } else if (k = BITSNS(7)) {
  252.         if (k & 0b10000000) {
  253.             k = FEP_CLR_CODE;
  254.         } else if (k & 0b01000000) {
  255.             k = 0;/*FEP_DNARROW_CODE;*/
  256.         } else if (k & 0b00100000) {
  257.             k = 0;/*FEP_RIGHTARROW_CODE;*/
  258.         } else if (k & 0b00010000) {
  259.             k = 0;/*FEP_UPARROW_CODE;*/
  260.         } else if (k & 0b00001000) {
  261.             k = 0;/*FEP_LEFTARROW_CODE;*/
  262.         } else if (k & 0b00000100) {
  263.             k = FEP_UNDO_CODE;
  264.         } else if (k & 0b00000010) {
  265.             k = 0;/*FEP_ROLLDN_CODE;*/
  266.         } else if (k & 0b00000001) {
  267.             k = 0;/*FEP_ROLLUP_CODE;*/
  268.         }
  269.     } else if (k = (BITSNS(0x0a) & 0b11111100)) {    /* XF1-5 */
  270.         if (k & 0b00100000) k = FEP_XF1_CODE;
  271.         else if (k & 0b01000000) k = FEP_XF2_CODE;
  272.         else if (k & 0b10000000) k = FEP_XF3_CODE;
  273.         else if (k & 0b00010000) k = FEP_HELP_CODE;
  274.         else if (k & 0b00001000) k = FEP_TOUROKU_CODE;
  275.         else k = FEP_KIGOU_CODE;
  276.     } else if (k = (BITSNS(0x0b))) {
  277.         if (k & 0b00000001) k = FEP_XF4_CODE;
  278.         else if (k & 0b00000010) k = FEP_XF5_CODE;
  279.         else if (k & 0b00000100) k = FEP_KANA_CODE;
  280.         else if (k & 0b00001000) k = FEP_ROMA_CODE;
  281.         else if (k & 0b00010000) k = FEP_CODE_CODE;
  282.         else if (k & 0b00100000) k = 0;/*FEP_CAPS_CODE;*/
  283.         else if (k & 0b01000000) k = FEP_INS_CODE;
  284.         else if (k & 0b10000000) k = 0;/*FEP_HIRAGANA_CODE;*/
  285.     }
  286.  
  287.     if (!k) {
  288.         return(fep_qxf2());
  289.     }
  290.  
  291.     return(k + fep_shift_ctrl());
  292. }
  293.  
  294. /* SHIFT なら 0x10, CTRL なら 0x20 */
  295. int
  296. fep_shift_ctrl()
  297. {
  298.     register int ks;
  299.  
  300.     if (ks = (BITSNS(0x0e) & 0b00000011)) {    /* SHIFT, CTRL */
  301.         if (ks & 1) {
  302.             return(0x10);    /* SHIFT */
  303.         } else {
  304.             return(0x20);    /* CTRL */
  305.         }
  306.     } else {
  307.         return(0);
  308.     }
  309. }
  310.  
  311. void
  312. fep_push_key(UINT c)
  313. {
  314.     if (MACRO_EXE_FLAG) {
  315.         MACRO_COUNT--;
  316.         return;
  317.     }
  318.  
  319.     if (fep_buffer) {
  320.         error("バグです1");
  321.     } else {
  322.         fep_buffer = c;
  323.     }
  324. }
  325.  
  326. UINT
  327. fep_under_inkey()
  328. {
  329.     return(fep_inkey());
  330. }
  331.  
  332. UINT
  333. fep_get_key()
  334. {
  335.     register UINT c;
  336.  
  337.     if (c = fep_INKEY()) {        /* 何か入力があった */
  338.         if ((c < 0x20) || isprkana(c)) {
  339.             return(c);
  340.             /* コントロールコード、もしくは普通の１バイトコード */
  341.         } else {
  342.             if (c <= 0x80) {
  343.                 c = (c << 8) | fep_INKEY();
  344.             }
  345.             return(c);
  346.         }
  347.     } else {
  348.         return(0);
  349.     }
  350. }
  351.  
  352. /* i == 0 ならなんでも入力 */
  353. /* さもなくばコマンドの２バイト目として判断して返す */
  354. UINT
  355. fep_inkey_command(i)
  356. {
  357.     if (i) {    /* 「半角英数字の大文字」or「コントロールコード」に決め込む */
  358.         return(fep_inkey_raw());
  359.     } else {
  360.         return(fep_inkey());
  361.     }
  362. }
  363.  
  364. /* １文字入力 */
  365. /* 0x00 ～ 0xff */
  366. /* 一時的にモードを解除して、キーボードより入力する */
  367. UINT
  368. fep_inkey_raw_not_code()
  369. {
  370.     UINT c;
  371.     UINT mode;
  372.  
  373.     mode = K_SFTSNS();
  374.     fep_ledset(0);
  375.     fep_mode_set0((STR)"H--M");
  376.     while(1) {
  377.         if (c = fep_qxf()) {    /* XF もしくはファンクションキーである */
  378. /*            etc_while_fep_qxf();*/
  379.             break;
  380.         } else if (c = fep_INKEY()) {    /* 何か入力があった */
  381.             if ((c < 0x20) || (isprkana(c))) {
  382.                 break;        /* 普通の１バイトコード */
  383.             }
  384.         } else if (K_SFTSNS() & 0b1000000) {
  385.             c = 0x10c;
  386.             break;
  387.         }
  388.     }
  389.     fep_mode_set(FP_MODE);
  390.     fep_ledset(mode);
  391.     return(toupper(c));
  392. }
  393.     
  394. /* １文字入力 */
  395. /* 0x00 ～ 0xff */
  396. /* 一時的にモードを解除して、キーボードより入力する */
  397. UINT
  398. fep_inkey_raw0()
  399. {
  400.     UINT c;
  401.     UINT mode;
  402.  
  403.     mode = K_SFTSNS();
  404.     fep_ledset(0);
  405. /*    fep_mode_set0((STR)"H--M");*/
  406.     while((c = fep_inkey()) >= 0x8000);    /* 全角はチャイ */
  407. /*    fep_mode_set(FP_MODE);*/
  408.     fep_ledset(mode);
  409.     return(toupper(c));
  410. }
  411.     
  412. /* １文字入力 */
  413. /* 0x00 ～ 0xff */
  414. /* 一時的にモードを解除して、キーボードより入力する */
  415. UINT
  416. fep_inkey_raw()
  417. {
  418.     UINT c;
  419.     UINT mode;
  420.  
  421.     mode = K_SFTSNS();
  422.     fep_ledset(0);
  423.     fep_mode_set0((STR)"H--M");
  424.     while((c = fep_inkey()) >= 0x8000);    /* 全角はチャイ */
  425.     fep_mode_set(FP_MODE);
  426.     fep_ledset(mode);
  427.     return(toupper(c));
  428. }
  429.     
  430. UBYTE fep_func_save[712];    /* ファンクションキーの保存 */
  431.  
  432. void
  433. fep_init_first()
  434. {
  435.     FNCKEYGT(0,fep_func_save);
  436. }
  437.  
  438. void
  439. fep_init()
  440. {
  441.     register UINT pcon;
  442.     UBYTE isask[] = "CON     ASK68KV2";
  443.     UINT i,a0;
  444.  
  445.     fep_buffer = 0;
  446.     if (!DUM_FLAG) {
  447.         KNJCTRL(7,0);    /* ロックする */
  448.     } else {
  449.         KNJCTRL(7,1);
  450.     }
  451. /*init_exit();etc_exit(0);*/
  452.     FIRST_FP_MODE = KNJCTRL(6);    /* 入力モードを読み出す */
  453. /*init_exit();etc_exit(0);*/
  454.  
  455.     fep_mode_set(FP_MODE);        /* 全角、ひらがな、ローマ字、変換 or "HKRH" */
  456.     strcpy(FP_MODE_HEN,FP_MODE);
  457.     strcpy(FP_MODE_MUHEN,"H--MH");
  458.     strcpy(FP_MODE_MUHEN_0,FP_MODE_MUHEN);
  459. /*init_exit();etc_exit(0);*/
  460.  
  461.     pcon = etc_get_last_con();
  462. /*window0();printf("[%x]",pcon);binkey();*/
  463.     a0 = pcon+0xe;
  464.     for(i=0;i<16;i++,a0++) {
  465.         if (B_BPEEK(a0) != isask[i]) {
  466.             break;
  467.         }
  468.     }
  469.     if (i != 16) {    /* ask.sys */
  470.         if ((VERSION = KNJCTRL(50)) < 300) {    /* Ver 2.XX */
  471.             fep_p1 = pcon + 0x4e5bf - 0x332b4;
  472.             fep_p2 = pcon + 0x4e5c1 - 0x332b4;
  473.             fep_pr = pcon + 0x51b56 - 0x332b4;
  474.         } else {                /* Ver 3.XX */
  475.             fep_p1 = pcon + 0x47a0b - 0x332b4;
  476.             fep_p2 = pcon + 0x47a0b - 0x332b4;
  477.             fep_pr = pcon + 0x47a0b - 0x332b4;
  478.         }
  479.     } else {    /* ask.x */
  480. /*error("ask.x");*/
  481.         fep_p1 = pcon + 0x8c5e3 - 0x71780;
  482.         fep_p2 = pcon + 0x8c5e5 - 0x71780;
  483.         fep_pr = pcon + 0x8fb7a - 0x71780;
  484.     }
  485. /*
  486. window0();
  487. printf("[%x][%x][%x]",fep_p1,fep_p2,fep_pr);
  488. binkey();
  489. */
  490.     if (!DUM_FLAG) {
  491.         fep_p2_last = B_BPEEK(fep_p2);
  492.     }
  493. }
  494.  
  495. fep_init_exit()
  496. {
  497.     fep_key_clear();
  498.     FNCKEYST(0,fep_func_save);
  499.     KNJCTRL(5,FIRST_FP_MODE);    /* 入力モードを戻す */
  500.     xf_dic_flush();
  501.     KNJCTRL(7,1);            /* アンロック */
  502. }
  503.  
  504.  
  505. UBYTE left[VERY_LONG_LINE],right[VERY_LONG_LINE];/*,right_r[MAXLINE];*/
  506. int leftc,rightc;
  507. int XF3_RUN;
  508. UINT under_first_x;
  509.  
  510. /* ^Q 対応の１行入力 */
  511. /* 指定された終了文字を返す */
  512. /* エコーする */
  513. /* max はエコー幅 */
  514. UINT
  515. fep_input_cr(STR s,int max,STR terminal)
  516. {
  517.     return(fep_input_esc0(s,max,terminal,0));
  518. }
  519.  
  520. /* ^Q 対応の１行入力 */
  521. /* 指定された終了文字を返す */
  522. /* エコーする */
  523. /* max はエコー幅 */
  524. /* ^G で終了したなら -1 を返す */
  525. UINT
  526. fep_input_esc(STR s,int max,STR terminal)
  527. {
  528.     return(fep_input_esc0(s,max,terminal,1));
  529. }
  530.  
  531. /* ^Q 対応の１行入力 */
  532. /* 指定された終了文字を返す */
  533. /* エコーする */
  534. /* max はエコー幅 */
  535. /* ^G で終了したなら -1 を返す */
  536. /* mode が 1 なら ESC で帰る、さもなくば CR で帰る */
  537. UINT
  538. fep_input_esc0(STR s,int max,STR terminal,int mode)
  539. {
  540.     UWORD ec;
  541.     int flag;
  542.     UINT c,c0;
  543.     STR p;
  544.     int x;
  545.  
  546.     *left = *right = EOS;
  547.     leftc = rightc = 0;    /* バッファカウンタを初期化 */
  548.     disp_cursor_on();    /* カーソルを出す */
  549.     disp_show_cursor();    /* カーソルのブリンクを強制的にオンにする */
  550.     while(1) {
  551.         c = fep_input_char(terminal,&ec);
  552.         switch(ec) {
  553.         case 'H'-'@':    /* ^H である */
  554.             if (rightc) {
  555.                 c = etc_jlast(right);    /* 最後の文字 */
  556.             } else if (leftc) {
  557.                 c = etc_jlast(left);    /* 最後の文字 */
  558.             } else {    /* 最後の文字がない */
  559.                 continue;    /* 何もしない */
  560.             }
  561.             if (mode && (c == CR)) {
  562.                 fep_input_minus(1);    /* １バイトバッファから削る */
  563.             } else {
  564.                 fep_input_minus(etc_char_byte_len(c));
  565.             }
  566.             fep_input_flush_bs();
  567.         continue;
  568.         case '_'-'@':    /* ^_ = [CLR] である */
  569.         case 'U'-'@':    /* ^U である */
  570.             *right = *left = EOS;
  571.             rightc = leftc = 0;
  572.             xf_init_tb_r();
  573.             fep_input_flush();
  574.         continue;
  575.         case '['-'@':    /* ESC である */
  576.             if (mode) {
  577.                 /* 普通に終了 */
  578.                 strcpy(s,left);
  579.                 strcat(s,right);
  580.                 return(ec);
  581.             } else {
  582.                 return(-1);
  583.             }
  584.  
  585.         case 'M'-'@':    /* CR である */
  586.         case 'J'-'@':    /* CR である */
  587.             if (rightc || TBUFFC_R) {
  588.                 goto ikinari_kakutei;
  589.             }
  590.             if (!mode) {
  591.                 /* 普通に終了 */
  592.                 strcpy(s,left);
  593.                 strcat(s,right);
  594.                 xf_cat_r_init(s,TBUFF_R);
  595. /*                strcat(s,TBUFF_R);*/
  596. /*                xf_init_tb_r();*/
  597.                 return(ec);
  598.             }
  599.             break;
  600.         continue;
  601.         case 'G'-'@':    /* ^G である */
  602.                 /* 無効で終了 */
  603.             return(-1);
  604.         continue;
  605.         default:
  606.         break;
  607.         }
  608.         if (((rightc + leftc) >= max) || (!c)) {
  609.             etc_beep();
  610.             continue;
  611.         }
  612.  
  613.         if (xf_check(c)) {
  614.             fep_input_flush();    /* カーソルをちゃんと戻す */
  615.         }
  616.         switch(c) {
  617.             int i;
  618.         case 0x103:    /* 変換開始 */
  619.             for(i=0;i<SEG_MAX;i++) {
  620.                 SEG_FLAG[i] = 0;
  621.             }
  622.             if (FP_MODE[3] != 'H') {    /* 変換モードでない */
  623.                 break;
  624.             }
  625.             if (!rightc) {    /* 変換する対象がない */
  626.                 break;
  627.             }
  628.             XF3_RUN = 0;
  629.             xf_cat_r_init(right,TBUFF_R);
  630. /*            strcpy(right_r,right);*/            /* 保存しておく */
  631.             kcount = KNJCTRL(19,right,kc,k1);    /* 19=変換開始 */
  632.             fnumber = 0;    /* 文節番号 */
  633.             SEG[fnumber][0] = EOS;
  634.             knumber = 1;    /* 候補番号 */
  635.             bnumber = 0;    /* ブロック番号 */
  636.             fep_xf_disp_1l(fnumber,kc,k1);
  637.             do {
  638.                 c0 = fep_inkey_raw();
  639.                 flag = fep_xf0_1l(c0);
  640.             } while(!flag);
  641.         break;
  642.  
  643.         case 0x104:    /* かな/カナ変換 */
  644.                 /* RAW color のまま変換する */
  645.                 /* かなに戻せばかな漢字変換可能 */
  646.             xf_cat_r_init(right,TBUFF_R);
  647.             if (FP_MODE[3] != 'H') {    /* 変換モードでない */
  648.                 break;
  649.             }
  650.             p = right;
  651.             while(1) {
  652.                 p = etc_jfirst_x(p,&c0);
  653.                 if (!p) break;    /* かな／カナが見付からなかった */
  654.                 if (jiskata(c0)) {
  655.                     etc_zen_kata_to_hira(right,right,MAXLINE);
  656.                     break;
  657.                 } else if (jishira(c0)) {
  658.                     etc_zen_hira_to_kata(right,right,MAXLINE);
  659.                     break;
  660.                 }
  661.                 /* 続行 */
  662.             }
  663.             fep_xf_disp_right();    /* 右側を新たに書く */
  664.             etc_while_fep_qxf();    /* 離されるまで待つ */
  665.         break;
  666.  
  667.         case TAB:
  668.         case CR:
  669.         case 'M'-'@':
  670.             if ((!rightc)&&(!TBUFFC_R)) {    /* 生入力がない */
  671.                 goto normal_input;
  672.             }
  673.         case 0x105:    /* いきなり全文確定 */
  674. ikinari_kakutei:
  675.             fep_under_ikinari_kakutei();
  676. #if 0
  677.             strcat(left,right);
  678.             xf_cat_r_init(left,TBUFF_R);
  679. /*            strcat(left,TBUFF_R);*/
  680. /*            xf_init_tb_r();*/
  681.             right[rightc = 0] = EOS;
  682.             fep_xf_disp_left();
  683.             leftc = strlen(left);
  684. /*            under_blanc();*/
  685.             etc_while_fep_qxf();    /* 離されるまで待つ */
  686. #endif
  687.         break;
  688.  
  689.         case 0x122:    /* CTRL+XF2 左側を確定 */
  690.             if (FP_MODE[3] != 'H') {    /* 変換モードでない */
  691.                 break;
  692.             }
  693.         break;
  694.  
  695.         case 0x114:    /* SHIFT+XF4 全角/半角変換 */
  696.         xf_cat_r_init(right,TBUFF_R);
  697.         if (FP_MODE[3] != 'H') {    /* 変換モードでない */
  698.             break;
  699.         }
  700.         p = right;
  701.         p = etc_jfirst_x(p,&c0);
  702.         if (!p) break;    /* かな／カナが見付からなかった */
  703.         if (c0 > 0x100) {    /* 全角ってことで */
  704.             etc_str_zen_to_han(right,right,MAXLINE);
  705.         } else {
  706.             etc_str_han_to_zen(right,right,MAXLINE);
  707.         }
  708.         rightc = strlen(right);
  709.         fep_xf_disp_right();    /* 右側を新たに書く */
  710.         B_PRINT("\x1b[0K");
  711.         etc_while_fep_qxf();    /* 離されるまで待つ */
  712.         break;
  713.  
  714.         case 0x1ff:
  715.             if (TBUFFC_R) {
  716.                 fep_input_flush();
  717.             } else {
  718.                 fep_input_flush_bs();
  719.             }
  720.         break;
  721.         default:
  722. normal_input:
  723. /* 幅チェック */
  724.             if ((c < 0x100) || (c >= 0x8000)) {    /* 普通の文字である */
  725.                 fep_input_add(c);
  726.                 fep_input_flush();
  727.                 break;
  728.             }
  729.         }
  730.     }
  731. }
  732.  
  733. void
  734. fep_xf_disp_convert(STR s,STR d)
  735. {
  736.     UBYTE w[VERY_LONG_LINE];
  737.     register int i = 0;
  738.     register UBYTE c;
  739.  
  740.     while(c = *s++) {
  741.         if (c == CR) {
  742.             w[i++] = '<';
  743.             w[i++] = 'N';
  744.             w[i++] = 'L';
  745.             w[i++] = '>';
  746.         } else if (c == TAB) {
  747.             w[i++] = '^';
  748.             w[i++] = 'I';
  749.         } else {
  750.             w[i++] = c;
  751.         }
  752.     }
  753.     w[i] = EOS;
  754.     cut_disp_convert(w,d,CURRENT_JIZUME);
  755. }
  756.  
  757. void
  758. fep_xf_disp_left()
  759. {
  760.     window_abs_loc(under_first_x,UNDER_Y);
  761.     fep_xf_disp_1(left);
  762. }
  763.  
  764. void
  765. fep_xf_disp_right()
  766. {
  767.     fep_xf_disp_left();
  768.     etc_color(RAW);
  769.     fep_xf_disp_1(right);
  770.     etc_color(NORMAL);
  771. }
  772.  
  773. void
  774. fep_xf_disp_1(STR l)
  775. {
  776.     UBYTE d[VERY_LONG_LINE];
  777.  
  778.     fep_xf_disp_convert(l,d);
  779.     B_PRINT(d);
  780. }
  781.  
  782. /* 指定されたバイト数をバッファから削る */
  783. /* EOS を埋め込むことを忘れずに */
  784. void
  785. fep_input_minus(int i)
  786. {
  787.     if (rightc) {
  788.         if (rightc >= i) {
  789.             rightc -= i;    /* right だけで間に合った */
  790.             right[rightc] = EOS;
  791.             return;
  792.         } else {
  793.             i -= rightc;
  794.             rightc = 0;    /* left に食い込む */
  795.             *right = EOS;
  796.         }
  797.     }
  798.     if (left) {
  799.         if (leftc >= i) {
  800.             leftc -= i;    /* left だけで間に合った */
  801.             left[leftc] = EOS;
  802.             return;
  803.         } else {
  804.             error("バグです2");
  805.         }
  806.     }
  807. }
  808.  
  809. /* １ライン変換表示 */
  810. /* の２点に挟まれた間を表示する */
  811. /* fn が現在作業中の文節 */
  812. void
  813. fep_xf_disp_1l(int fn,STR kc,STR k1)
  814. {
  815.     UBYTE f0[TBUFF_SIZE];
  816.     register int i;
  817.  
  818.     window_abs_loc(under_first_x,UNDER_Y);
  819.     fep_xf_disp_left();    /* 変換の対象になっていない左を表示する */
  820.  
  821.     *f0 = EOS;
  822.     for(i=0;i<fn;i++) {
  823.         strcat(f0,SEG[i]);
  824.     }    /* 半確定の文節をひとつにまとめる */
  825.  
  826. /* era_box * 3 が無駄 */
  827.     if (*f0) {
  828.         etc_color(OFUSI);
  829.         fep_xf_disp_1(f0);
  830.     }
  831.  
  832.     etc_color(CFUSI);
  833.     fep_xf_disp_1(kc);
  834.  
  835.     if (*k1) {
  836.         etc_color(OFUSI);
  837.         fep_xf_disp_1(k1);
  838.     }
  839.     etc_color(NORMAL);
  840.     B_PRINT("\x1b[0K");    /* 文字列が短くなっている可能性があるので右側を消す */
  841. /*    etc_while_fep_qxf();*/    /* 離されるまで待つ */
  842. }
  843.  
  844. /* 文字を追加する */
  845. void
  846. fep_input_add(UINT c)
  847. {
  848.     UBYTE c0,c1;
  849.     UWORD cd;
  850.  
  851.     if ((c == L'゜') || (c == L'゛')) {
  852.         if (rightc) {
  853.             cd = etc_jlast(right);    /* 最後の文字 */
  854.         } else if (leftc) {
  855.             cd = etc_jlast(left);    /* 最後の文字 */
  856.         } else {    /* 最後の文字がない */
  857.             goto fep_inpu_add_ok;
  858.         }
  859.         if ((c == L'゛') && (etc_dakuten_able_under(cd))) {
  860.                 fep_input_minus(etc_char_byte_len(cd));
  861.                 fep_input_add(cd+1);
  862.                 return;
  863.         }
  864.         if ((c == L'゜') && (etc_handakuten_able_under(cd))) {
  865.                 fep_input_minus(etc_char_byte_len(cd));
  866.                 fep_input_add(cd+2);
  867.                 return;
  868.         }
  869.     }
  870.  
  871. fep_inpu_add_ok:
  872.     if (c >= 0x100) {    /* ２バイト文字である */
  873.         c0 = (c >> 8);
  874.         c1 = c & 0xff;
  875.     } else {
  876.         c0 = c;
  877.         c1 = 0;
  878.     }
  879.  
  880.     if (FP_MODE[3] == 'H') {    /* 変換モードである */
  881.         right[rightc++] = c0;
  882.         if (c1) {
  883.             right[rightc++] = c1;
  884.         }
  885.         right[rightc] = EOS;
  886.     } else {            /* 変換モードでない */
  887.         left[leftc++] = c0;
  888.         if (c1) {
  889.             left[leftc++] = c1;
  890.         }
  891.         left[leftc] = EOS;
  892.     }
  893. }
  894.  
  895. /* 一行クリアしてから */
  896. /* アンダー入力をフラッシュする */
  897. void
  898. fep_input_flush_bs()
  899. {
  900.     etc_color(NORMAL);
  901.     fep_input_flush();
  902. }
  903.  
  904. /* アンダー入力をフラッシュする */
  905. void
  906. fep_input_flush()
  907. {
  908.     UBYTE d[VERY_LONG_LINE];
  909.  
  910.     etc_color(NORMAL);
  911.     fep_xf_disp_convert(left,d);
  912.     window_abs_loc(under_first_x,UNDER_Y);
  913.     B_PRINT(d);
  914.     etc_color(RAW);
  915.     fep_xf_disp_convert(right,d);
  916.     B_PRINT(d);
  917.     xf_disp_tb_r_under();
  918.     etc_color(NORMAL);
  919.     B_PRINT("\x1b[0K");
  920. }
  921.  
  922. /* ^Q 対応の１文字入力 */
  923. UINT
  924. fep_input_char(STR terminal,UWORD *endcode)
  925. {
  926.     UINT c;
  927.  
  928.     *endcode = EOS;
  929.     if ((c = fep_inkey()) == (QUOTE)) {    /* ^Q なら */
  930.         return(fep_inkey());        /* 次の１バイトは無条件 */
  931.     } else {
  932.         if (c < 0x100) {
  933.             if (strchr(terminal,c)) {    /* 終了条件 */
  934.                 *endcode = c;
  935.                 return(0);
  936.             }
  937.             if (c == 'M'-'@') {    /* ^M なら */
  938.                 c = CR;        /* 改行にすりかえる */
  939.             } else if (c == 'H'-'@') {    /* ^H なら */
  940.                 *endcode = c;
  941.             }
  942.         }
  943.         return(c);
  944.     }
  945. }
  946.  
  947. /* １ライン変換実行 */
  948. int
  949. fep_xf0_1l(int c)
  950. {
  951.     int w;
  952.     short ws;
  953.     UBYTE kc0[TBUFF_SIZE];
  954.     int knumber0;
  955.     int kohox;
  956.  
  957.  
  958.     switch(c) {
  959.  
  960.     case 0x1ff:
  961.     return(0);
  962.     case 0x101:        /* XF1:前文節へ */
  963.     if (fnumber > 0) {
  964.         etc_func_on();
  965.         kcount = KNJCTRL(35,kc,k1);    /* 35=前文節への移動 */
  966.         fnumber--;
  967.         knumber = 1;    /* 候補番号 */
  968.         bnumber = 0;    /* ブロック番号 */
  969.         XF3_RUN = 0;
  970.         fep_xf_disp_1l(fnumber,kc,k1);
  971.     }
  972.     break;
  973.  
  974.     case '1':
  975.     case '2':
  976.     case '3':
  977.     case '4':
  978.     case '5':
  979.     case '6':
  980.     case '7':
  981.     case '8':
  982.     case '9':    /* 数値選択をして次候補 */
  983.     knumber = c -'0';
  984.     if ((knumber < koho_max) && (XF3_RUN >= 2)) {
  985.         strcpy(kc,koho_10[knumber]);
  986.         /* break しない */
  987.     } else {
  988.         etc_beep();
  989.         break;
  990.     }
  991.  
  992.     case 0x102:        /* 次文節へ */
  993.     strcpy(SEG[fnumber],kc);
  994.     if (w = KNJCTRL(25,knumber,kc0,kc,k1,&ws)) {
  995.         etc_func_on();
  996.         if (kcount = ws) {
  997.             fnumber++;
  998.             knumber = 1;    /* 候補番号 */
  999.             bnumber = 0;    /* ブロック番号 */
  1000.             XF3_RUN = 0;
  1001.             fep_xf_disp_1l(fnumber,kc,k1);
  1002.         } else {    /* 次の候補がない＝最後の文節である */
  1003.             strcpy(kc,SEG[fnumber]);
  1004.             goto kakutei;
  1005.         }
  1006.     } else {
  1007.         etc_beep();
  1008.     }
  1009.     break;
  1010.  
  1011.     case 0x103:        /* 次候補:XF0 だから */
  1012. migikoho:
  1013.     switch (XF3_RUN) {
  1014.     case 0:
  1015.     /* 通常次候補 */
  1016.     /* 無条件に第一ブロック */
  1017.     XF3_RUN++;
  1018.     if (KNJCTRL(21,kc,k1)) {    /* 21=候補群ブロック内の次候補を得る */
  1019.             /* すんなり見付かった */
  1020.         knumber++;
  1021.         fep_xf_disp_1l(fnumber,kc,k1);
  1022.         break;
  1023.     } else {    /* 候補１個だけで、数値選択モード突入 */
  1024.     }    /* 底抜けだよーん */
  1025.  
  1026.     case 1:
  1027.     /* 数値選択状態突入 */
  1028.     etc_func_off();    /* ファンクションキーの表示を消す */
  1029.     knumber0 = knumber;
  1030.     while(knumber0 != 1) {    /* 戻る */
  1031.         knumber0--;
  1032.         w = KNJCTRL(20,kc,k1);    /* 20=候補群ブロック内の前候補を得る */
  1033.     }
  1034.     knumber++;
  1035.     strcpy(koho_10[1],kc);    /* 最初は１ */
  1036.     knumber0 = 2;
  1037.     while(1) {
  1038.         if (KNJCTRL(21,kc,k1)) {
  1039.             strcpy(koho_10[knumber0++],kc);
  1040.         } else {
  1041.             koho_10[knumber0][0] = EOS;
  1042.             koho_max = knumber0;
  1043.             break;
  1044.         }
  1045.     }
  1046.  
  1047.     if (!*koho_10[knumber]) {    /* 数字選択状態突入と同時に候補が無ければ */
  1048.                     /* ２つの候補だけ表示する */
  1049.         knumber = 1;
  1050.     }
  1051.  
  1052.     disp_koho_block(knumber);
  1053.     strcpy(kc,koho_10[knumber]);
  1054.     fep_xf_disp_1l(fnumber,kc,k1);
  1055.     XF3_RUN++;
  1056.     break;
  1057.  
  1058.     case 2:
  1059.     default:
  1060.     /* 数字選択状態継続 */
  1061.     knumber0 = knumber++;
  1062.     if (*koho_10[knumber]) {    /* ある */
  1063.         kohox = koho_10x[knumber0];
  1064.         if (disp_koho(knumber0,knumber,&kohox,koho_10[knumber0])) {
  1065.             /* 表示しきれない */
  1066.         }
  1067. /*        kohox = koho_10x[knumber];*/
  1068.         if (disp_koho(knumber,knumber,&kohox,koho_10[knumber])) {
  1069.                 /* 表示しきれない */
  1070.         }
  1071.         strcpy(kc,koho_10[knumber]);
  1072.         fep_xf_disp_1l(fnumber,kc,k1);
  1073.     } else {            /* もうない */
  1074.         if (KNJCTRL(23,kc,k1)) {    /* 次候補ブロックの作成 */
  1075.                 /* あった */
  1076.             bnumber++;
  1077.         } else {    /* 無かった */
  1078.             while(KNJCTRL(22,kc,k1));    /* 前候補ブロックの作成 */
  1079.                             /* 最初まで遡る */
  1080.             bnumber = 0;
  1081.         }
  1082.         knumber = 1;
  1083.         strcpy(koho_10[1],kc);    /* 最初は１ */
  1084.         knumber0 = 2;
  1085.         while(1) {
  1086.             if (KNJCTRL(21,kc,k1)) {
  1087.                 strcpy(koho_10[knumber0++],kc);
  1088.             } else {
  1089.                 koho_10[knumber0][0] = EOS;
  1090.                 koho_max = knumber0;
  1091.                 break;
  1092.             }
  1093.         }
  1094.         if (!*koho_10[knumber]) {
  1095.             knumber = 1;
  1096.         }
  1097.         disp_koho_block(knumber);
  1098.         strcpy(kc,koho_10[knumber]);
  1099.         fep_xf_disp_1l(fnumber,kc,k1);
  1100.     }
  1101.     break;
  1102.     }
  1103.     break;
  1104.  
  1105.     case 0x114:    /* 半角／全角変換 */
  1106.     KNJCTRL(37,kc,k1);    /* 37=先頭文節をカタカナにする */
  1107.     if (SEG_FLAG[fnumber]) {
  1108.         etc_str_han_to_zen(kc,kc,MAXLINE);    /* 先頭文節を全角にする */
  1109.         SEG_FLAG[fnumber] = 0;
  1110.         fep_xf_disp_1l(fnumber,kc,k1);
  1111.     } else {
  1112.         etc_str_zen_to_han(kc,kc,MAXLINE);    /* 先頭文節を半角にする */
  1113.         SEG_FLAG[fnumber] = 1;
  1114.         fep_xf_disp_1l(fnumber,kc,k1);
  1115.         B_PRINT("\x1b[0K");        
  1116.     }
  1117.     XF3_RUN = 0;
  1118.     etc_func_on();
  1119.     etc_while_fep_qxf();    /* 離されるまで待つ */
  1120.     break;
  1121.  
  1122.     case 0x104:    /* ひらがな／カタカナ変換 */
  1123. /* 最初はとにかく「ひらがな」へ */
  1124. /* その後はトグル */
  1125.     if (etc_is_there_han2byte(kc)) {
  1126.         etc_beep();
  1127.         under_print("現在の状態ではひらがな⇔カタカナ変換はできません");
  1128.         break;
  1129.     }
  1130.     if (SEG_FLAG[fnumber]) {
  1131.         w = KNJCTRL(37,kc,k1);    /* 37=先頭文節をカタカナにする */
  1132.         SEG_FLAG[fnumber] = 0;
  1133.     } else {
  1134.         w = KNJCTRL(38,kc,k1);    /* 38=先頭文節をひらがなにする */
  1135.         SEG_FLAG[fnumber] = 1;
  1136.     }
  1137.     XF3_RUN = 0;
  1138.     etc_func_on();
  1139.     fep_xf_disp_1l(fnumber,kc,k1);
  1140.     etc_while_fep_qxf();    /* 離されるまで待つ */
  1141.     break;
  1142.  
  1143.     case TAB:
  1144.     case 'M'-'@':
  1145.     case CR:
  1146.     case 0x105:    /* 全体確定 */
  1147. kakutei:
  1148.     etc_func_on();
  1149.     if (XF3_RUN >= 2) {    /* 数字選択状態だった */
  1150.         UBYTE d1[MAXLINE],d2[MAXLINE];
  1151.         w = KNJCTRL(25,knumber,kc,d1,d2,&ws);
  1152.     }
  1153.     {
  1154.         UBYTE tlast[MAXLINE];
  1155.         int i;
  1156.  
  1157.         for(i=0;i<fnumber;i++) {
  1158.             strcat(left,SEG[i]);
  1159.         }    /* 半確定の文節をひとつにまとめる */
  1160.         strcat(left,kc);
  1161.         strcat(left,k1);
  1162.         w = KNJCTRL(24,tlast);    /* 全体確定 */
  1163.     /* 変換後が長すぎる場合の切り詰めを検出できないので tlast はダミー */
  1164.     }
  1165.     xf_init_tb_r();
  1166.     right[rightc = 0] = EOS;
  1167.     fep_xf_disp_left();
  1168.     leftc = strlen(left);
  1169.     xf_init_tb();
  1170.     B_PRINT("\x1b[0K");
  1171. /*    under_blanc();*/
  1172.     etc_while_fep_qxf();    /* 離されるまで待つ */
  1173.     return(1);
  1174.  
  1175.     case 0x111:    /* 文節を短くする */
  1176.     etc_func_on();
  1177.     w = KNJCTRL(34,kc,k1);    /* 34=先頭文節を１文字短くして再変換 */
  1178.     XF3_RUN = 0;
  1179.     fep_xf_disp_1l(fnumber,kc,k1);
  1180.     break;
  1181.  
  1182.     case 0x112:    /* 文節を長くする */
  1183.     etc_func_on();
  1184.     w = KNJCTRL(33,kc,k1);    /* 33=先頭文節を１文字長くして再変換 */
  1185.     XF3_RUN = 0;
  1186.     fep_xf_disp_1l(fnumber,kc,k1);
  1187.     break;
  1188.  
  1189.     case '['-'@':    /* キャンセル */
  1190.     etc_func_on();
  1191.     fep_xf_disp_right();
  1192.     etc_while_fep_qxf();    /* 離されるまで待つ */
  1193.     return(2);
  1194.     break;
  1195.  
  1196.     default:
  1197.     if (c == XF_NEXT_BLOCK_KEY) {    /* 次候補ブロックへ */
  1198.         knumber = 1;
  1199.         if (KNJCTRL(23,kc,k1)) {    /* 次候補ブロックの作成 */
  1200.             bnumber++;
  1201.             strcpy(koho_10[1],kc);    /* 最初は１ */
  1202.             knumber0 = 2;
  1203.             while(1) {
  1204.                 if (KNJCTRL(21,kc,k1)) {
  1205.                     strcpy(koho_10[knumber0++],kc);
  1206.                 } else {
  1207.                     koho_10[knumber0][0] = EOS;
  1208.                     koho_max = knumber0;
  1209.                     break;
  1210.                 }
  1211.             }
  1212.         }
  1213.         strcpy(kc,koho_10[knumber]);
  1214.         disp_koho_block(knumber);
  1215.         fep_xf_disp_1l(fnumber,kc,k1);
  1216.         break;
  1217.     }
  1218.  
  1219.     if (c == XF_BEFORE_BLOCK_KEY) {    /* 前候補ブロックへ */
  1220.         knumber = 1;
  1221.         if (bnumber) {
  1222.             bnumber--;
  1223. maeblock:
  1224.             KNJCTRL(22,kc,k1);    /* 前候補ブロックの作成 */
  1225.             strcpy(koho_10[1],kc);    /* 最初は１ */
  1226.             knumber0 = 2;
  1227.             while(1) {
  1228.                 if (KNJCTRL(21,kc,k1)) {
  1229.                     strcpy(koho_10[knumber0++],kc);
  1230.                 } else {
  1231.                     koho_10[knumber0][0] = EOS;
  1232.                     koho_max = knumber0;
  1233.                     break;
  1234.                 }
  1235.             }
  1236.         }
  1237.         strcpy(kc,koho_10[knumber]);
  1238.         disp_koho_block(knumber);
  1239.         fep_xf_disp_1l(fnumber,kc,k1);
  1240.         break;
  1241.     }
  1242.  
  1243.     if (c == XF_RIGHT_KOHO_KEY) {    /* 右候補へ */
  1244.         goto migikoho;
  1245. /*        break;*/
  1246.     }
  1247.     if (c == XF_LEFT_KOHO_KEY) {    /* 左候補へ */
  1248.         /* 数字選択状態にして左候補へ */
  1249.         if (XF3_RUN >= 4) {    /* すでに数字選択状態だった */
  1250.             if (knumber > 1) {    /* 前候補ブロックに行かなくてもよい */
  1251.                 knumber0 = knumber--;
  1252.                 kohox = koho_10x[knumber];
  1253.                 if (disp_koho(knumber,knumber,&kohox,koho_10[knumber])) {
  1254.                     /* 表示しきれない */
  1255.                 }
  1256.                 if (disp_koho(knumber0,knumber,&kohox,koho_10[knumber0])) {
  1257.                     /* 表示しきれない */
  1258.                 }
  1259.             } else {        /* 前候補ブロックへ行く */
  1260.                 if (bnumber) {    /* 前ブロックがあるはず */
  1261.                     bnumber--;
  1262.                     knumber = 9;
  1263.                     goto maeblock;    /* 前候補ブロックへ */
  1264.                 }
  1265.             }
  1266.         } else {        /* まだ数字選択状態ではない */
  1267.             knumber0 = knumber;
  1268.             if (knumber > 1) {
  1269.                 knumber--;
  1270.             }
  1271.             XF3_RUN = 5;    /* フラグみたいなもの */
  1272.             etc_func_off();    /* ファンクションキーの表示を消す */
  1273.             while(knumber0 != 1) {    /* 戻る */
  1274.                 knumber0--;
  1275.                 w = KNJCTRL(20,kc,k1);    /* 20=候補群ブロック内の前候補を得る */
  1276.             }
  1277.             strcpy(koho_10[1],kc);    /* 最初は１ */
  1278.             knumber0 = 2;
  1279.             while(1) {
  1280.                 if (KNJCTRL(21,kc,k1)) {
  1281.                     strcpy(koho_10[knumber0++],kc);
  1282.                 } else {
  1283.                     koho_10[knumber0][0] = EOS;
  1284.                     koho_max = knumber0;
  1285.                     break;
  1286.                 }
  1287.             }
  1288.             disp_koho_block(knumber);
  1289.         }
  1290.         strcpy(kc,koho_10[knumber]);
  1291.         fep_xf_disp_1l(fnumber,kc,k1);
  1292.         break;
  1293.     }
  1294.  
  1295.     /* スペース以外の普通の文字 -> 全体を確定して、プッシュ */
  1296.     etc_func_on();
  1297.     w = KNJCTRL(24,right);    /* 全体確定 */
  1298.     strcat(left,right);
  1299.     leftc += rightc;
  1300.     rightc = 0;
  1301.     fep_xf_disp_left();
  1302.     etc_while_fep_qxf();    /* 離されるまで待つ */
  1303.     xf_init_tb();
  1304.     fep_push_key(c);
  1305.     etc_while_fep_qxf();    /* 離されるまで待つ */
  1306.     return(1);
  1307.      break;
  1308.     }
  1309.     fep_key_clear();
  1310.     etc_while_fep_qxf();    /* 離されるまで待つ */
  1311.     return(0);
  1312. }
  1313.  
  1314. /* 全角　ひらがな　ＩＮＳ　ＣＡＰＳ　コード　ローマ　かな */
  1315. /* 全角　ひらがな　ＩＮＳ　ＣＡＰＳ　コード　ローマ　かな opt2 opt1 ctrl shift */
  1316. void
  1317. fep_follow_led()
  1318. {
  1319.     if ((FP_MODE[0] == 'Z') && (!(K_SFTSNS() & 0b10000000000))) {
  1320.         LEDMOD(6,1);
  1321.     }
  1322.     if ((FP_MODE[0] != 'Z') && (K_SFTSNS() & 0b10000000000)) {
  1323.         LEDMOD(6,0);
  1324.     }
  1325.     if ((FP_MODE[2] == 'R') && (!(K_SFTSNS() & 0b00000100000))) {
  1326.         LEDMOD(1,1);
  1327.     }
  1328.     if ((FP_MODE[2] != 'R') && (K_SFTSNS() & 0b00000100000)) {
  1329.         LEDMOD(1,0);
  1330.     }
  1331.     if ((FP_MODE[1] == (UBYTE)'K') && (!(K_SFTSNS() & 0b00000010000))) {
  1332.         LEDMOD(0,1);
  1333.     }
  1334.     if ((FP_MODE[1] != (UBYTE)'K') && (K_SFTSNS() & 0b00000010000)) {
  1335.         LEDMOD(0,0);
  1336.     }
  1337. }
  1338.  
  1339. /* 全角　ひらがな　ＩＮＳ　ＣＡＰＳ　コード　ローマ　かな */
  1340. /* 全角　ひらがな　ＩＮＳ　ＣＡＰＳ　コード　ローマ　かな opt2 opt1 ctrl shift */
  1341. void
  1342. fep_follow_led0()
  1343. {
  1344.     LEDMOD(6,(FP_MODE[0] == 'Z'));
  1345.     LEDMOD(1,(FP_MODE[2] == 'R'));
  1346.     LEDMOD(0,(FP_MODE[1] == 'K'));
  1347.     LEDMOD(5,(FP_MODE[4] == 'H'));
  1348. }
  1349.  
  1350. void
  1351. fep_get_led0()
  1352. {
  1353.     FP_MODE[4] = "-H"[!!(K_SFTSNS() & 0b01000000000)];
  1354. }
  1355.  
  1356. void
  1357. fep_ledset(UINT m)
  1358. {
  1359.     register int i,mask;
  1360.  
  1361.     m >>= 4;
  1362.     for(mask=1,i=0;i<=6;i++,mask<<=1) {
  1363.         LEDMOD(i,!!(m & mask));
  1364. /*
  1365. if (i == 3) {
  1366. window0();printf("[%x]",m);binkey();
  1367. }
  1368. */
  1369.     }
  1370. }
  1371.  
  1372. /* 何か入力があるまで待つ */
  1373. UINT
  1374. fep_INKEY_wait()
  1375. {
  1376.     register UINT c;
  1377.  
  1378.     while(!(c = fep_INKEY()));
  1379.     return(c);
  1380. }
  1381.  
  1382. /* 待たない */
  1383. UINT
  1384. fep_INKEY()
  1385. {
  1386.     register UINT c;
  1387.  
  1388.     if (c = fep_INKEY_sub()) {
  1389.         etc_click();
  1390.     }
  1391.     return(c);
  1392. }
  1393.  
  1394. /* 待たない */
  1395. UINT
  1396. fep_INKEY_sub()
  1397. {
  1398.     register UINT q_func,c,c0;
  1399.     register int delta;
  1400.  
  1401.     if (DUM_FLAG)  {
  1402.         if (iskanji(c = INPOUT(0xff))) {
  1403.             c = (c << 8) | INPOUT(0xff);
  1404.         }
  1405.         return(c);
  1406.     }
  1407.  
  1408.     if (q_func = fep_qxf()) {    /* XF もしくはファンクションキーである */
  1409. /*        etc_while_fep_qxf();*/
  1410.         if ((0x200 < q_func) && (q_func < 0x210)) {    /* f1 - f10 である */
  1411. /*            return(fep_INKEY());*/
  1412.         } else {
  1413.             return(q_func);
  1414.         }
  1415.     }
  1416.  
  1417.     if (c = (KNJCTRL(53) & 0xff)) {
  1418.         if (iskanji(c)) {
  1419.             c0 = (KNJCTRL(53) & 0xff);
  1420.             c = (c << 8) | (c0 & 0xff);
  1421.             fep_INKEY_0();
  1422.             return(c);
  1423.         } else if ((c == CR) || (c == 'M'-'@')) {
  1424.             if (UNDER_FLAG) {
  1425.                 xf_flush_tb_r_under();
  1426.             } else {
  1427.                 xf_flush_tb_r();
  1428.             }
  1429.             fep_INKEY_0();
  1430.             return(c); 
  1431.         } else if (c == 'H'-'@') {    /* bs */
  1432.             if (!TBUFFC_R) {    /* ローマ字の途中がない */
  1433.                 return(c);
  1434.             }
  1435.         } else {    /* 普通の半角 */
  1436.             fep_INKEY_0();
  1437.             return(c);
  1438.         }
  1439.     }
  1440.     return(fep_INKEY_0());
  1441. }
  1442.  
  1443. UINT
  1444. fep_INKEY_0()
  1445. {
  1446.     if (DUM_FLAG) {
  1447.         return(0);
  1448.     }
  1449.  
  1450. /*    if ((VERSION < 300) && (B_BPEEK(fep_p2) != fep_p2_last)) {*/
  1451.     if (VERSION >= 300) {
  1452.         if (B_BPEEK(fep_p2) != fep_p2_last) {
  1453.             fep_p2_last = B_BPEEK(fep_p2);
  1454.             xf_tb_r_follow();
  1455. /*            xf_init_tb_r();*/
  1456.             return(0x1ff);
  1457.         }
  1458.         xf_tb_r_follow();
  1459. /*        return(0x1ff);*/
  1460.     }
  1461.     if (B_BPEEK(fep_p2) != fep_p2_last) {
  1462.         fep_p2_last = B_BPEEK(fep_p2);
  1463.         xf_tb_r_follow();
  1464.         return(0x1ff);
  1465.     } else {    
  1466.         fep_p2_last = B_BPEEK(fep_p2);
  1467.     }
  1468.     return(0);
  1469. }
  1470.  
  1471. void
  1472. fep_under_ikinari_kakutei()
  1473. {
  1474.     strcat(left,right);
  1475.     xf_cat_r_init(left,TBUFF_R);
  1476.     right[rightc = 0] = EOS;
  1477.     fep_xf_disp_left();
  1478.     leftc = strlen(left);
  1479.     etc_while_fep_qxf();    /* 離されるまで待つ */
  1480. }
  1481.